/**
 * 通用js方法封装处理
 * Copyright (c) 2019 ruoyi
 */

const baseURL = process.env.VUE_APP_BASE_API

// 日期格式化
export function parseTime(time, pattern) {
  if (arguments.length === 0 || !time) {
    return null
  }
  const format = pattern || '{y}-{m}-{d} {h}:{i}:{s}'
  let date
  if (typeof time === 'object') {
    date = time
  } else {
    if ((typeof time === 'string') && (/^[0-9]+$/.test(time))) {
      time = parseInt(time)
    } else if (typeof time === 'string') {
      time = time.replace(new RegExp(/-/gm), '/');
    }
    if ((typeof time === 'number') && (time.toString().length === 10)) {
      time = time * 1000
    }
    date = new Date(time)
  }
  const formatObj = {
    y: date.getFullYear(),
    m: date.getMonth() + 1,
    d: date.getDate(),
    h: date.getHours(),
    i: date.getMinutes(),
    s: date.getSeconds(),
    a: date.getDay()
  }
  const time_str = format.replace(/{(y|m|d|h|i|s|a)+}/g, (result, key) => {
    let value = formatObj[key]
    // Note: getDay() returns 0 on Sunday
    if (key === 'a') {
      return ['日', '一', '二', '三', '四', '五', '六'][value]
    }
    if (result.length > 0 && value < 10) {
      value = '0' + value
    }
    return value || 0
  })
  return time_str
}

// 日期格式化(字符串)  针对"2020-12-01T00:00:00.000+0800"这种，sql查出来放到map里面的
export function parseDate(time, pattern) {
  if (arguments.length === 0 || !time) {
    return null
  }

  if (time.toString().length >= 10) {
    return time.toString().substring(0,10)
  }else{
    return null
  }
}

// 表单重置
export function resetForm(refName) {
  if (this.$refs[refName]) {
    this.$refs[refName].resetFields();
  }
}

// 添加日期范围
export function addDateRange(params, dateRange) {
  var search = params;
  search.beginTime = "";
  search.endTime = "";
  if (null != dateRange && '' != dateRange) {
    search.beginTime = dateRange[0];
    search.endTime = dateRange[1];
  }
  return search;
}

// 回显数据字典
export function selectDictLabel(datas, value) {
  var actions = [];
  Object.keys(datas).some((key) => {
    if (datas[key].dictValue == ('' + value)) {
      actions.push(datas[key].dictLabel);
      return true;
    }
  })
  return actions.join('');
}

// 回显数据字典（字符串数组）
export function selectDictLabels(datas, value, separator) {
  var actions = [];
  var currentSeparator = undefined === separator ? "," : separator;
  var temp = value.split(currentSeparator);
  Object.keys(value.split(currentSeparator)).some((val) => {
    Object.keys(datas).some((key) => {
      if (datas[key].dictValue == ('' + temp[val])) {
        actions.push(datas[key].dictLabel + currentSeparator);
      }
    })
  })
  return actions.join('').substring(0, actions.join('').length - 1);
}

// 通用下载方法
export function download(fileName) {
  window.location.href = baseURL + "/common/download?fileName=" + encodeURI(fileName) + "&delete=" + true;
}

// 字符串格式化(%s )
export function sprintf(str) {
  var args = arguments,
    flag = true,
    i = 1;
  str = str.replace(/%s/g, function() {
    var arg = args[i++];
    if (typeof arg === 'undefined') {
      flag = false;
      return '';
    }
    return arg;
  });
  return flag ? str : '';
}

// 转换字符串，undefined,null等转化为""
export function praseStrEmpty(str) {
  if (!str || str == "undefined" || str == "null") {
    return "";
  }
  return str;
}

/**
 * 构造树型结构数据
 * @param {*} data 数据源
 * @param {*} id id字段 默认 'id'
 * @param {*} parentId 父节点字段 默认 'parentId'
 * @param {*} children 孩子节点字段 默认 'children'
 * @param {*} rootId 根Id 默认 0
 */
export function handleTree(data, id, parentId, children, rootId) {
  id = id || 'id'
  parentId = parentId || 'parentId'
  children = children || 'children'
  rootId = rootId || Math.min.apply(Math, data.map(item => {
    return item[parentId]
  })) || 0
  //对源数据深度克隆
  const cloneData = JSON.parse(JSON.stringify(data))
  //循环所有项
  const treeData = cloneData.filter(father => {
    let branchArr = cloneData.filter(child => {
      //返回每一项的子级数组
      return father[id] === child[parentId]
    });
    branchArr.length > 0 ? father.children = branchArr : '';
    //返回第一层
    return father[parentId] === rootId;
  });
  return treeData != '' ? treeData : data;
}

/**
 * 转换专业门类数据结构，级联下拉列表
 * data为列表[{},{},...]
 * 每一个对象里面包含4个字段
 {
   pcode:'',  //父节点ID
   plabel:'', //父节点名称
   ccode:'',  //子节点ID
   clabel:''  //子节点名称
 }
 例如：
 pcode  plabel            cdode   clabel
 124	  通用标准
 125	  咨询
 126	  规划
 127	  勘测与设计	        130	    勘测
 127	  勘测与设计	        131	    设计
 128	  施工与监管	        132	    施工与安装
 128	  施工与监管	        133	    材料与试验
 128	  施工与监管	        134	    设备装备
 128	  施工与监管	        135	    监管与验收
 128	  施工与监管	        136	    资料归档
 129	  行政管理与运行管理	137	    行政管理
 129	  行政管理与运行管理	138	    公共服务
 129	  行政管理与运行管理	139	    运行维护
 129	  行政管理与运行管理	140	    监测预测
*/
export function cascaderNormalizer(data) {
  var options = [];
  var children = [];
  var parent;
  var child;
  var current_plabel = ''; //记录当前父节点名称
  for (var i = 0; i < data.length; i++) {
    if (i == 0) {
      //当前父节点名称
      current_plabel = data[i].plabel;
      //先判断是否有子节点
      if (data[i].ccode != null && data[i].ccode != '') {
        //子项赋值
        child = {
          value: data[i].ccode,
          label: data[i].clabel,
        }
        //添加一个子项
        children.push(child);
      }

      //是否最后一个值
      if (data.length == (i + 1)) {
        //父项赋值
        if (children.length == 0) children = null;
        parent = {
          value: data[i].pcode,
          label: data[i].plabel,
          children: children
        }
        //添加一个父项
        options.push(parent);
      }
    } else {
      //判断当前父节点是否为同一个
      if (current_plabel == data[i].plabel) {
        //先判断是否有子节点
        if (data[i].ccode != null && data[i].ccode != '') {
          //子项赋值
          child = {
            value: data[i].ccode,
            label: data[i].clabel,
          }
          //添加一个子项
          children.push(child);
        }

        //是否最后一个值
        if (data.length == (i + 1)) {
          if (children.length == 0) children = null;
          //父项赋值
          parent = {
            value: data[i].pcode,
            label: data[i].plabel,
            children: children
          }
          //添加一个父项
          options.push(parent);
        }
      } else { //不同父类
        //结束上一个父节点
        if (children.length == 0) children = null;
        //父项赋值
        parent = {
          value: data[i - 1].pcode,
          label: data[i - 1].plabel,
          children: children
        }
        //添加一个父项
        options.push(parent);

        //开启新的节点
        current_plabel = data[i].plabel; //新的父节点名称
        children = []; //新的子节点
        //先判断是否有子节点
        if (data[i].ccode != null && data[i].ccode != '') {
          //子项赋值
          child = {
            value: data[i].ccode,
            label: data[i].clabel,
          }
          //添加一个子项
          children.push(child);
        }

        //是否最后一个值
        if (data.length == (i + 1)) {
          if (children.length == 0) children = null;
          //父项赋值
          parent = {
            value: data[i].pcode,
            label: data[i].plabel,
            children: children
          }
          //添加一个父项
          options.push(parent);
        }
      }
    }
  }
  return options;
}
//根据角色key获取wstatus
export function getFlowStatus(CurrNodeK) {
  var status = '1'
  if(CurrNodeK=='operator') {//退回
    status = '1'
  }else if (CurrNodeK=='end') {//完成
    status = '3'
  }else {//办理中
    status = '2'
  }
  return status
}
